#include <iostream>
using namespace std;

// 6 3
// 2 4
// 1 5
// 3 5
// 5 2 1 4 3 6

const int N = 10010;
int n, m, root, idx;

struct Tree
{
	int s[2], size, v, p, flag;
	void init(int _p, int _v)
	{
		v = _v;
		p = _p;
	}
} tr[N];

void pushdown(int x)
{
	if (tr[x].flag)
	{
		swap(tr[x].s[0],tr[x].s[1]);
		tr[tr[x].s[0]].flag ^= 1;
		tr[tr[x].s[1]].flag ^= 1;
		tr[x].flag = 0;
	}
}

void output(int x)
{
	pushdown(x);
	if(x)
	{
		output(tr[x].s[0]);
		if(tr[x].v>=1&&tr[x].v<=n)
		{
			cout << tr[x].v << " ";
		}
		output(tr[x].s[1]);
	}
}

int get_k(int k)
{
	int u = root;
	while (u)
	{
		pushdown(u);
		if (tr[tr[u].s[0]].size >= k)
		{
			u = tr[u].s[0];
		}
		else if (tr[tr[u].s[0]].size + 1 == k)
		{
			return u;
		}
		else
		{
			k -= tr[tr[u].s[0]].size + 1;
			u = tr[u].s[1];
		}
	}
	return -1;
}

void pushup(int x)
{
	tr[x].size = tr[tr[x].s[0]].size + tr[tr[x].s[1]].size + 1;
}

void rotate(int x)
{
	int y = tr[x].p;
	int z = tr[y].p;
	int k = tr[y].s[1] == x;
	tr[y].s[k] = tr[x].s[k ^ 1];
	tr[tr[x].s[k ^ 1]].p = y;
	tr[z].s[tr[z].s[1] == y] = x;
	tr[x].p = z;
	tr[x].s[k ^ 1] = y;
	tr[y].p = x;
	pushup(y);
	pushup(x);
}

void splay(int x, int k)
{
	while (tr[x].p != k)
	{
		int y = tr[x].p;
		int z = tr[y].p;
		if (z != k)
		{
			if ((tr[y].s[1] == x) ^ (tr[z].s[1] == y))
			{
				rotate(x);
			}
			else
			{
				rotate(y);
			}
		}
		rotate(x);
	}
	if (!k)
	{
		root = x;
	}
}

void insert(int v)
{
	int u = root, p = 0;
	while (u)
	{
		p = u;
		u = tr[u].s[v > tr[u].v];
	}
	u = ++idx;
	if (p)
	{
		tr[p].s[v > tr[p].v] = u;
	}
	tr[u].init(p, v);
	splay(u, 0);
}

int main()
{
	cin >> n >> m;
	for (int i = 0; i <= n + 1; i++)
	{
		insert(i);
	}
	while(m--)
	{
		int l, r;
		cin >> l >> r;
		l = get_k(l);
		r = get_k(r + 2);
		splay(l, 0);
		splay(r, l);
		tr[tr[r].s[0]].flag ^= 1;
	}
	output(root);
	return 0;
}

// #include<iostream>
// using namespace std;

// const int N = 10010;

// int n, m, root, idx;

// void insert(int v);
// void splay(int x, int k);
// void rotate(int x);
// void pushup(int x);
// void pushdown(int x);
// int get_k(int k);
// void output(int u);

// struct Tree
// {
// 	int s[2], v, size, p, flag;
// 	void init(int _v, int _p)
// 	{
// 		v = _v;
// 		p = _p;
// 	}
// } tr[N];

// void insert(int v)
// {
// 	int u = root, p = 0;
// 	while (u)
// 	{
// 		p = u;
// 		u = tr[u].s[v > tr[u].v];
// 	}
// 	u = ++idx;
// 	if (p)
// 	{
// 		tr[p].s[v > tr[p].v] = u;
// 	}
// 	tr[u].init(v, p);
// 	splay(u, 0);
// }

// void splay(int x, int k)
// {
// 	while (tr[x].p != k)
// 	{
// 		int y = tr[x].p;
// 		int z = tr[y].p;
// 		if (z != k)
// 		{
// 			if ((tr[z].s[1] == y) ^ (tr[y].s[1] == x))
// 			{
// 				rotate(x);
// 			}
// 			else
// 			{
// 				rotate(y);
// 			}
// 		}
// 		rotate(x);
// 	}
// 	if (!k)
// 	{
// 		root = x;
// 	}
// }

// void rotate(int x)
// {
// 	int y = tr[x].p;
// 	int z = tr[y].p;
// 	int k = tr[y].s[1] == x;
// 	tr[y].s[k] = tr[x].s[k ^ 1];
// 	tr[tr[x].s[k ^ 1]].p = y;
// 	tr[z].s[tr[z].s[1] == y] = x;
// 	tr[x].p = z;
// 	tr[x].s[k ^ 1] = y;
// 	tr[y].p = x;
// 	pushup(y);
// 	pushup(x);
// }

// void pushdown(int x)
// {
// 	if (tr[x].flag)
// 	{
// 		swap(tr[x].s[0], tr[x].s[1]);
// 		tr[tr[x].s[0]].flag ^= 1;
// 		tr[tr[x].s[1]].flag ^= 1;
// 		tr[x].flag = 0;
// 	}
// }

// int get_k(int k)
// {
// 	int u = root;
// 	while (u)
// 	{
// 		pushdown(u);
// 		if (tr[tr[u].s[0]].size >= k)
// 		{
// 			u = tr[u].s[0];
// 		}
// 		else if (tr[tr[u].s[0]].size + 1 == k)
// 		{
// 			return u;
// 		}
// 		else
// 		{
// 			k -= tr[tr[u].s[0]].size + 1;
// 			u = tr[u].s[1];
// 		}
// 	}
// 	return -1;
// }

// void output(int u)
// {
// 	pushdown(u);
// 	if (u)
// 	{
// 		output(tr[u].s[0]);
// 		if (tr[u].v >= 1 && tr[u].v <= n)
// 		{
// 			cout << tr[u].v << " ";
// 		}
// 		output(tr[u].s[1]);
// 	}
// }

// void pushup(int x)
// {
// 	tr[x].size = tr[tr[x].s[0]].size + tr[tr[x].s[1]].size + 1;
// }

// int main()
// {
// 	cin >> n >> m;
// 	for (int i = 0; i <= n + 1; i++)
// 	{
// 		insert(i);
// 	}
// 	while (m--)
// 	{
// 		int l, r;
// 		cin >> l >> r;
// 		l = get_k(l);
// 		r = get_k(r + 2);
// 		splay(l, 0);
// 		splay(r, l);
// 		tr[tr[r].s[0]].flag ^= 1;
// 	}
// 	output(root);
// 	return 0;
// }

// #include <iostream>
// using namespace std;

// int n, m;
// const int N = 100010;
// int root, idx;

// void insert(int v);
// void splay(int x, int k);
// void rotate(int x);
// void pushup(int x);
// void pushdown(int x);
// int get_k(int k);
// void print(int x);

// struct Tree
// {
//     int s[2], p, v, size, flag;
//     void init(int _p, int _v)
//     {
//         p = _p;
//         v = _v;
//     }
// } tr[N];

// void insert(int v)
// {
//     int u = root, p = 0;
//     while (u)
//     {
//         p = u;
//         u = tr[u].s[v > tr[u].v];
//     }
//     u = ++idx;
//     if (p)
//     {
//         tr[p].s[v > tr[p].v] = u;
//     }
//     tr[u].init(p, v);
//     splay(u, 0);
// }

// void splay(int x, int k)
// {
//     while (tr[x].p != k)
//     {
//         int y = tr[x].p;
//         int z = tr[y].p;
//         if (z != k)
//         {
//             if ((tr[z].s[1] == y) ^ (tr[y].s[1] == x))
//             {
//                 rotate(x);
//             }
//             else
//             {
//                 rotate(y);
//             }
//         }
//         rotate(x);
//     }
//     if (!k)
//     {
//         root = x;
//     }
// }

// void rotate(int x)
// {
//     int y = tr[x].p;
//     int z = tr[y].p;
//     int k = tr[y].s[1] == x;
//     tr[y].s[k] = tr[x].s[k ^ 1];
//     tr[tr[x].s[k ^ 1]].p = y;
//     tr[z].s[tr[z].s[1] == y] = x;
//     tr[x].p = z;
//     tr[x].s[k ^ 1] = y;
//     tr[y].p = x;
//     pushup(y);
//     pushup(x);
// }

// void pushup(int x)
// {
//     tr[x].size = tr[tr[x].s[0]].size + tr[tr[x].s[1]].size + 1;
// }

// void pushdown(int x)
// {
//     if (tr[x].flag)
//     {
//         swap(tr[x].s[0], tr[x].s[1]);
//         tr[x].flag = 0;
//         tr[tr[x].s[0]].flag ^= 1;
//         tr[tr[x].s[1]].flag ^= 1;
//     }
// }

// int get_k(int k)
// {
//     int u = root;
//     while (u)
//     {
//         pushdown(u);
//         if (tr[tr[u].s[0]].size >= k)
//         {
//             u = tr[u].s[0];
//         }
//         else if (tr[tr[u].s[0]].size + 1 == k)
//         {
//             return u;
//         }
//         else
//         {
//             k -= tr[tr[u].s[0]].size + 1;
//             u = tr[u].s[1];
//         }
//     }
//     return -1;
// }

// void print(int i)
// {
//     pushdown(i);
//     if (i)
//     {
//         print(tr[i].s[0]);
//         if (tr[i].v >= 1 && tr[i].v <= n)
//         {
//             cout << tr[i].v << " ";
//         }
//         print(tr[i].s[1]);
//     }
// }

// int main()
// {
//     cin >> n >> m;
//     for (int i = 0; i <= n + 1; i++)
//     {
//         insert(i);
//     }
//     while (m--)
//     {
//         int l, r;
//         cin >> l >> r;
//         l = get_k(l);
//         r = get_k(r + 2);
//         splay(l, 0);
//         splay(r, l);
//         tr[tr[r].s[0]].flag ^= 1;
//     }
//     print(root);
// }